// index/pages/answerReport/answerReport.js
Page({
  data: {
    // 答题报告数据
    reportData: {
      total: 0,
      correct: 0,
      wrong: 0,
      unanswered: 0,
      correctRate: 0,
      totalTime: '',
      completeTime: '',
      questionBankName: ''
    },
    
    // 题目状态数组
    questionNumbers: [],
    
    // 题库ID
    questionBankId: null,
    
    // 用户登录状态
    isUserLoggedIn: false,
    
    // 是否为自动保存模式
    isAutoSaveMode: false,
    
    // 自动保存是否成功
    autoSaveSuccess: false,
    
    // 计时相关
    startTime: null,        // 答题开始时间
    currentTime: null,      // 当前时间
    elapsedSeconds: 0,      // 已过秒数
    timerInterval: null,    // 计时器ID
    isTimerRunning: false   // 计时器是否运行中
  },

  onLoad(options) {
    console.log('答题详情页面加载，参数:', options);
    
    // 获取传递的答题数据
    if (options.reportData) {
      try {
        const reportData = JSON.parse(decodeURIComponent(options.reportData));
        console.log('解析后的答题数据:', reportData);
        console.log('增强答题状态数据:', reportData.enhancedAnswerStatus);
        console.log('题目ID映射:', reportData.questionIdMap);
        
        this.setData({ 
          reportData,
          questionBankId: reportData.questionBankId || null
        });
        this.processReportData(reportData);
        
        // 默认启用自动保存模式（除非明确指定不自动保存）
        const shouldAutoSave = options.autoSave !== 'false';
        if (shouldAutoSave) {
          console.log('启用自动保存模式，准备自动保存答题记录');
          this.setData({ isAutoSaveMode: true });
          // 延迟一下再自动保存，确保页面完全加载
          setTimeout(() => {
            this.autoSaveAnswerRecord();
          }, 1500);
        }
      } catch (e) {
        console.error('解析答题数据失败:', e);
        this.loadDefaultData();
      }
    } else if (options.questionBankId) {
      // 如果没有答题数据，但有题库ID，可以尝试从本地存储获取
      this.setData({ questionBankId: options.questionBankId });
      this.loadReportFromStorage(options.questionBankId);
    } else {
      this.loadDefaultData();
    }
    
    // 检查用户登录状态
    this.checkUserLoginStatus();
    
    // 启动计时器（如果页面没有答题数据，说明是新的答题，需要计时）
    if (!options.reportData) {
      console.log('启动答题计时器');
      // 延迟启动计时器，确保页面数据已设置完成
      setTimeout(() => {
        this.startTimer();
      }, 100);
    } else {
      console.log('答题已完成，显示静态时间数据');
    }
  },

    /**
   * 主要HTTP请求方法（直接使用wx.request）
   * @param {string} url - 请求地址
   * @param {object} data - 请求数据
   * @param {boolean} silent - 是否为静默模式（不显示加载提示和成功提示）
   */
  directHttpRequest(url, data, silent = false) {
    console.log('使用主要HTTP请求方法:', url, data, '静默模式:', silent);
    
    // 获取用户认证token
    const { getToken } = require('../../../utils/storageUtil.js');
    const token = getToken();
    
    if (!token) {
      console.error('未找到用户认证token');
      if (!silent) {
        wx.hideLoading();
        wx.showToast({
          title: '认证失败，请重新登录',
          icon: 'none',
          duration: 2000
        });
      }
      return;
    }
    
    console.log('获取到认证token:', token);
    
    // 如果不是静默模式，显示加载提示
    if (!silent) {
      wx.showLoading({
        title: '保存中...',
        mask: true
      });
    }
    
    // 直接使用wx.request
    wx.request({
      url: `http://localhost:8080${url}`,
      method: 'POST',
      data: data,
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${token}`
      },
      success: (res) => {
        if (!silent) {
          wx.hideLoading();
        }
        console.log('HTTP请求成功:', res);
        
        if (res.statusCode === 200) {
          if (!silent) {
            wx.showToast({
              title: '保存成功',
              icon: 'success',
              duration: 2000
            });
          }
          console.log('答题记录保存成功:', res.data);
          // 更新自动保存状态
          this.setData({ 
            isAutoSaveMode: true,
            autoSaveSuccess: true 
          });
        } else {
          if (!silent) {
            wx.showToast({
              title: `保存失败 (HTTP ${res.statusCode})`,
              icon: 'none',
              duration: 2000
            });
          }
          // 更新自动保存状态
          this.setData({ 
            autoSaveSuccess: false 
          });
        }
      },
      fail: (err) => {
        if (!silent) {
          wx.hideLoading();
          wx.showToast({
            title: '网络请求失败',
            icon: 'none',
            duration: 2000
          });
        }
        console.error('HTTP请求失败:', err);
      }
    });
  },



  /**
   * 跳转到登录页面
   */
  goToLogin() {
    wx.navigateTo({
      url: '/my/pages/Login/Login'
    });
  },

  /**
   * 检查用户登录状态（页面加载时调用）
   */
  checkUserLoginStatus() {
    try {
      const { isLogin } = require('../../../utils/userManager.js');
      
      if (isLogin()) {
        console.log('页面加载时检查：用户已登录');
        this.setData({
          isUserLoggedIn: true
        });
      } else {
        console.log('页面加载时检查：用户未登录');
        this.setData({
          isUserLoggedIn: false
        });
      }
    } catch (e) {
      console.error('检查用户登录状态失败:', e);
      this.setData({
        isUserLoggedIn: false
      });
    }
  },

  /**
   * 确保所有题目都被包含在答题状态数组中
   */
  ensureAllQuestionsIncluded(questionNumbers, totalQuestions) {
    if (questionNumbers.length >= totalQuestions) {
      return; // 已经包含所有题目
    }
    
    console.log(`确保包含所有题目: 当前${questionNumbers.length}题，总共${totalQuestions}题`);
    
    // 找出缺失的题目索引
    const existingIndices = new Set(questionNumbers.map(item => item.originalIndex));
    const missingIndices = [];
    
    for (let i = 0; i < totalQuestions; i++) {
      if (!existingIndices.has(i)) {
        missingIndices.push(i);
      }
    }
    
    console.log('缺失的题目索引:', missingIndices);
    
    // 为缺失的题目添加未答状态，尝试获取真实题目ID
    missingIndices.forEach(index => {
      const questionNumber = questionNumbers.length + 1;
      
      // 尝试从questionIdMap获取真实的题目ID
      let questionId = null;
      if (this.data.reportData && this.data.reportData.questionIdMap && this.data.reportData.questionIdMap[index]) {
        questionId = this.data.reportData.questionIdMap[index];
        console.log(`为索引${index}的未答题获取到真实题目ID: ${questionId}`);
      } else if (this.data.questionBankId) {
        // 如果有题库ID，生成一个更有意义的占位ID
        questionId = `q_bank_${this.data.questionBankId}_${index}`;
        console.log(`为索引${index}的未答题生成题库相关ID: ${questionId}`);
      } else {
        // 最后的备选方案，生成一个通用占位ID
        questionId = `q_${index}`;
        console.log(`为索引${index}的未答题生成通用占位ID: ${questionId}`);
      }
      
      questionNumbers.push({
        number: questionNumber,
        status: 'unanswered',
        originalIndex: index,
        questionId: questionId
      });
    });
    
    // 重新排序，确保题目按原始索引顺序排列
    questionNumbers.sort((a, b) => a.originalIndex - b.originalIndex);
    
    // 重新编号
    questionNumbers.forEach((item, index) => {
      item.number = index + 1;
    });
    
    console.log('补充后的完整题目状态数组:', questionNumbers);
  },

  /**
   * 处理答题报告数据
   */
  processReportData(reportData) {
    console.log('处理答题报告数据:', reportData);
    
    // 计算未答题数和正确率
    const unanswered = reportData.total - reportData.correct - reportData.wrong;
    const correctRate = reportData.total ? Math.round((reportData.correct / reportData.total) * 100) : 0;
    
    // 格式化时间显示（如果reportData中没有时间数据或时间为0，使用当前计时器的时间）
    let timeToDisplay = reportData.totalTime;
    if ((!timeToDisplay || timeToDisplay === 0) && this.data.isTimerRunning) {
      timeToDisplay = this.data.elapsedSeconds;
    }
    const formattedTime = this.formatDisplayTime(timeToDisplay);
    
    // 构建题目状态数组
    const questionNumbers = [];
    
    // 优先使用增强答题状态数据
    if (reportData.enhancedAnswerStatus && Object.keys(reportData.enhancedAnswerStatus).length > 0) {
      console.log('使用增强答题状态数据');
      console.log('增强答题状态详情:', reportData.enhancedAnswerStatus);
      
      // 遍历增强答题状态，按索引排序
      const sortedIndices = Object.keys(reportData.enhancedAnswerStatus)
        .map(Number)
        .sort((a, b) => a - b);
      
      console.log('排序后的索引:', sortedIndices);
      
      sortedIndices.forEach((index, arrayIndex) => {
        const answerItem = reportData.enhancedAnswerStatus[index];
        const questionNumber = arrayIndex + 1;
        const originalIndex = index;
        
        console.log(`处理索引 ${index}:`, answerItem);
        console.log(`题目ID: ${answerItem.questionId}, 状态: ${answerItem.status}`);
        
        questionNumbers.push({
          number: questionNumber,
          status: answerItem.status,
          originalIndex: originalIndex,
          questionId: answerItem.questionId || null
        });
      });
      
      console.log('从增强答题状态构建的题目状态数组:', questionNumbers);
      
      // 确保所有题目都被包含，包括未答题目
      this.ensureAllQuestionsIncluded(questionNumbers, reportData.total);
      
    } else if (reportData.answerStatus && Object.keys(reportData.answerStatus).length > 0) {
      console.log('使用基础答题状态数据');
      
      // 使用基础答题状态数据
      const sortedIndices = Object.keys(reportData.answerStatus)
        .map(Number)
        .sort((a, b) => a - b);
      
      sortedIndices.forEach((index, arrayIndex) => {
        const status = reportData.answerStatus[index];
        const questionNumber = arrayIndex + 1;
        const originalIndex = index;
        
        // 尝试从questionIdMap获取题目ID
        let questionId = null;
        if (reportData.questionIdMap && reportData.questionIdMap[index]) {
          questionId = reportData.questionIdMap[index];
        }
        
        questionNumbers.push({
          number: questionNumber,
          status: status,
          originalIndex: originalIndex,
          questionId: questionId
        });
      });
      
      console.log('从基础答题状态构建的题目状态数组:', questionNumbers);
      
      // 确保所有题目都被包含，包括未答题目
      this.ensureAllQuestionsIncluded(questionNumbers, reportData.total);
      
         } else {
       console.log('没有答题状态数据，生成完整题目状态数组');
       // 如果没有答题状态数据，生成包含所有题目的状态数组
       // 这样可以显示未答题目
       for (let i = 1; i <= reportData.total; i++) {
         let status = 'unanswered';
         if (i <= reportData.correct) {
           status = 'correct';
         } else if (i <= reportData.correct + reportData.wrong) {
           status = 'wrong';
         }
         
         // 优先从questionIdMap获取真实的题目ID
         let questionId = null;
         if (reportData.questionIdMap && reportData.questionIdMap[i - 1]) {
           questionId = reportData.questionIdMap[i - 1];
           console.log(`第${i}题获取到真实题目ID: ${questionId}`);
         } else if (reportData.questionBankId) {
           // 如果有题库ID，生成一个更有意义的占位ID
           questionId = `q_bank_${reportData.questionBankId}_${i - 1}`;
           console.log(`第${i}题生成题库相关ID: ${questionId}`);
         } else {
           // 最后的备选方案，生成一个通用占位ID
           questionId = `q_${i - 1}`;
           console.log(`第${i}题生成通用占位ID: ${questionId}`);
         }
         
         questionNumbers.push({
           number: i,
           status: status,
           originalIndex: i - 1,
           questionId: questionId
         });
       }
       
       console.log('生成的完整题目状态数组:', questionNumbers);
     }
    
    // 更新数据
    this.setData({
      'reportData.unanswered': unanswered,
      'reportData.correctRate': correctRate,
      'reportData.formattedTime': formattedTime,
      questionNumbers: questionNumbers
    });
    
    console.log('处理后的答题数据:', this.data.reportData);
    console.log('题目状态数组:', questionNumbers);
  },

  /**
   * 将时间字符串转换为秒数
   */
  convertTimeStringToSeconds(timeStr) {
    if (!timeStr) return 0;
    
    // 如果已经是数字，直接返回
    if (typeof timeStr === 'number') {
      return timeStr;
    }
    
    // 如果是字符串格式的时间，解析为秒数
    if (typeof timeStr === 'string') {
      // 处理 "1小时30分20秒" 格式
      const hourMatch = timeStr.match(/(\d+)小时/);
      const minuteMatch = timeStr.match(/(\d+)分/);
      const secondMatch = timeStr.match(/(\d+)秒/);
      
      const hours = hourMatch ? parseInt(hourMatch[1]) : 0;
      const minutes = minuteMatch ? parseInt(minuteMatch[1]) : 0;
      const seconds = secondMatch ? parseInt(secondMatch[1]) : 0;
      
      // 转换为总秒数
      return hours * 3600 + minutes * 60 + seconds;
    }
    
    return 0;
  },

  /**
   * 构建符合接口要求的答题记录数据
   */
  buildAnswerRecordData() {
     const { reportData, questionNumbers } = this.data;
     
     // 构建答对题目ID列表
     const correctList = questionNumbers
       .filter(item => item.status === 'correct' && item.questionId)
       .map(item => item.questionId);
     
     // 构建答错题目ID列表
     const wrongList = questionNumbers
       .filter(item => item.status === 'wrong' && item.questionId)
       .map(item => item.questionId);
     
     // 构建未答题目ID列表
     const unansweredList = questionNumbers
       .filter(item => item.status === 'unanswered' && item.questionId)
       .map(item => item.questionId);
     
         // 将时间字符串转换为秒数（优先使用计时器的真实时间）
    let timeToUse = reportData.totalTime;
    if (this.data.isTimerRunning || this.data.elapsedSeconds > 0) {
      timeToUse = this.data.elapsedSeconds;
    }
    const timeUsedInSeconds = this.convertTimeStringToSeconds(timeToUse);
     
     // 构建答题记录数据
     const answerRecord = {
       // 必填字段
       userId: this.getUserId(), // 需要实现获取用户ID的方法
       totalCount: reportData.total,
       
       // 可选字段
       bankId: reportData.questionBankId || null,
       correctList: JSON.stringify(correctList), // 转换为JSON字符串
       wrongList: JSON.stringify(wrongList), // 转换为JSON字符串
       unansweredList: JSON.stringify(unansweredList), // 转换为JSON字符串
       recordType: '章节训练', // 使用数据库允许的枚举值
       timeUsed: timeUsedInSeconds, // 耗时（秒）
       createTime: new Date().toISOString().slice(0, 19).replace('T', ' ') // 创建时间
     };
     
     console.log('构建的答题记录数据:', answerRecord);
     return answerRecord;
   },

  /**
   * 检查用户登录状态
   */
  checkUserLogin() {
    try {
      const { isLogin } = require('../../../utils/userManager.js');
      
      if (isLogin()) {
        console.log('用户已登录');
        return true;
      } else {
        console.log('用户未登录，提示登录');
        wx.showModal({
          title: '需要登录',
          content: '保存答题记录需要先登录，是否前往登录？',
          confirmText: '去登录',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              // 跳转到登录页面
              wx.navigateTo({
                url: '/my/pages/Login/Login'
              });
            }
          }
        });
        return false;
      }
    } catch (e) {
      console.error('检查用户登录状态失败:', e);
      wx.showToast({
        title: '检查登录状态失败',
        icon: 'none',
        duration: 2000
      });
      return false;
    }
  },

  /**
   * 获取用户ID
   */
  getUserId() {
    try {
      // 使用用户管理工具获取用户ID
      const { getUserId } = require('../../../utils/userManager.js');
      const userId = getUserId();
      
      if (userId) {
        console.log('获取到用户ID:', userId);
        return userId;
      } else {
        // 如果没有用户信息，提示用户登录
        console.warn('未找到用户信息，请先登录');
        wx.showToast({
          title: '请先登录',
          icon: 'none',
          duration: 2000
        });
        return null;
      }
    } catch (e) {
      console.error('获取用户ID失败:', e);
      wx.showToast({
        title: '获取用户信息失败',
        icon: 'none',
        duration: 2000
      });
      return null;
    }
  },

  /**
   * 从本地存储加载答题报告
   */
  loadReportFromStorage(questionBankId) {
    try {
      const storageKey = `answerReport_${questionBankId}`;
      const reportData = wx.getStorageSync(storageKey);
      
      if (reportData) {
        this.setData({ reportData });
        this.processReportData(reportData);
      } else {
        this.loadDefaultData();
      }
    } catch (e) {
      console.error('从存储加载答题报告失败:', e);
      this.loadDefaultData();
    }
  },

  /**
   * 加载默认数据（用于演示）
   */
  loadDefaultData() {
    const defaultData = {
      total: 10,
      correct: 8,
      wrong: 2,
      unanswered: 0,
      correctRate: 80,
      totalTime: 0, // 初始化为0，让计时器来管理时间
      completeTime: this.formatTime(new Date()),
      questionBankName: '山东大学338生物化学'
    };
    
    this.setData({ reportData: defaultData });
    this.processReportData(defaultData);
  },

  /**
   * 格式化时间
   */
  formatTime(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hour = String(date.getHours()).padStart(2, '0');
    const minute = String(date.getMinutes()).padStart(2, '0');
    
    return `${year}-${month}-${day} ${hour}:${minute}`;
  },

  /**
   * 开始计时
   */
  startTimer() {
    if (this.data.isTimerRunning) {
      console.log('计时器已在运行中');
      return;
    }
    
    const startTime = Date.now();
    console.log('开始计时，开始时间:', startTime);
    
    this.setData({
      startTime: startTime,
      currentTime: startTime,
      elapsedSeconds: 0,
      isTimerRunning: true
    });
    
    // 启动计时器，每秒更新一次
    const timerInterval = setInterval(() => {
      const currentTime = Date.now();
      const elapsedSeconds = Math.floor((currentTime - startTime) / 1000);
      
      console.log('计时器更新，已过秒数:', elapsedSeconds);
      
      this.setData({
        currentTime: currentTime,
        elapsedSeconds: elapsedSeconds
      });
      
      // 更新显示时间
      this.updateDisplayTime(elapsedSeconds);
    }, 1000);
    
    this.setData({ timerInterval: timerInterval });
    console.log('计时器已启动');
  },

  /**
   * 停止计时
   */
  stopTimer() {
    if (!this.data.isTimerRunning) {
      console.log('计时器未运行');
      return;
    }
    
    if (this.data.timerInterval) {
      clearInterval(this.data.timerInterval);
    }
    
    const finalElapsedSeconds = this.data.elapsedSeconds;
    console.log('停止计时，总耗时:', finalElapsedSeconds, '秒');
    
    this.setData({
      isTimerRunning: false,
      timerInterval: null
    });
    
    return finalElapsedSeconds;
  },

  /**
   * 更新显示时间
   */
  updateDisplayTime(elapsedSeconds) {
    const formattedTime = this.formatDisplayTime(elapsedSeconds);
    console.log('更新显示时间，秒数:', elapsedSeconds, '格式化后:', formattedTime);
    
    // 更新答题报告数据中的时间显示
    this.setData({
      'reportData.formattedTime': formattedTime,
      'reportData.totalTime': elapsedSeconds
    });
  },

  /**
   * 格式化显示时间
   */
  formatDisplayTime(timeStr) {
    if (!timeStr) return '00:00';
    
    // 如果已经是格式化的时间字符串，直接返回
    if (typeof timeStr === 'string' && timeStr.includes(':')) {
      return timeStr;
    }
    
    // 如果是秒数，转换为时分秒格式
    if (typeof timeStr === 'number' || !isNaN(parseInt(timeStr))) {
      const totalSeconds = parseInt(timeStr);
      const hours = Math.floor(totalSeconds / 3600);
      const minutes = Math.floor((totalSeconds % 3600) / 60);
      const seconds = totalSeconds % 60;
      
      if (hours > 0) {
        return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
      } else {
        return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
      }
    }
    
    // 如果是其他格式的时间字符串，尝试解析
    if (typeof timeStr === 'string') {
      // 处理 "1小时30分20秒" 格式
      const hourMatch = timeStr.match(/(\d+)小时/);
      const minuteMatch = timeStr.match(/(\d+)分/);
      const secondMatch = timeStr.match(/(\d+)秒/);
      
      const hours = hourMatch ? parseInt(hourMatch[1]) : 0;
      const minutes = minuteMatch ? parseInt(minuteMatch[1]) : 0;
      const seconds = secondMatch ? parseInt(secondMatch[1]) : 0;
      
      if (hours > 0) {
        return `${hours}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
      } else {
        return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
      }
    }
    
    return '00:00';
  },

  /**
   * 查看题目详情
   */
  viewQuestionDetail(e) {
    const index = e.currentTarget.dataset.index;
    const questionNumber = e.currentTarget.dataset.number;
    
    console.log(`查看第${questionNumber}题详情，索引: ${index}`);
    
    // 验证数据有效性
    if (typeof questionNumber === 'undefined' || questionNumber === null) {
      wx.showToast({
        title: '题目数据异常',
        icon: 'error'
      });
      return;
    }
    
    // 获取题目状态和题目ID
    let statusText = '未知';
    let questionId = null;
    if (this.data.questionNumbers && this.data.questionNumbers[index]) {
      const questionData = this.data.questionNumbers[index];
      const status = questionData.status;
      questionId = questionData.questionId;
      
      if (status === 'correct') {
        statusText = '答对';
      } else if (status === 'wrong') {
        statusText = '答错';
      } else if (status === 'unanswered') {
        statusText = '未答';
      }
    }
    
    // 构建状态信息
    let content = `题目状态: ${statusText}`;
    if (questionId) {
      content += `\n题目ID: ${questionId}`;
    }
    content += '\n\n是否查看详细解析？';
    
    // 询问用户是否查看详细解析
    wx.showModal({
      title: `第${questionNumber}题详情`,
      content: content,
      confirmText: '查看解析',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          // 跳转到题目解析页面查看详细解析
          this.viewQuestionAnalysis(questionNumber, index);
        }
      }
    });
  },

  /**
   * 查看指定题目的详细解析
   */
  viewQuestionAnalysis(questionNumber, index) {
    const { questionNumbers } = this.data;
    
    // 获取目标题目的ID
    const targetQuestion = questionNumbers[index];
    if (!targetQuestion) {
      wx.showToast({
        title: '题目数据获取失败',
        icon: 'error'
      });
      return;
    }
    
    // 检查题目ID，即使是占位ID也可以跳转
    if (!targetQuestion.questionId) {
      wx.showToast({
        title: '题目ID获取失败',
        icon: 'error'
      });
      return;
    }
    
    // 跳转到题目解析页面查看详细解析
    wx.navigateTo({
      url: `/index/pages/questionAnalysis/questionAnalysis?questionId=${targetQuestion.questionId}&pageTitle=第${questionNumber}题解析`
    });
  },

  /**
   * 显示全部解析
   */
  showAllAnalysis() {
    const { reportData, questionNumbers, questionBankId } = this.data;
    
    console.log('显示全部解析 - 当前数据:', {
      reportData,
      questionNumbers,
      questionBankId
    });
    
    if (!questionNumbers || questionNumbers.length === 0) {
      wx.showToast({
        title: '暂无题目数据',
        icon: 'none'
      });
      return;
    }
    
    // 准备跳转参数
    const jumpParams = {
      mode: 'review', // 复习模式
      from: 'answerReport', // 来源：答题报告
      questionBankId: questionBankId || reportData.questionBankId,
      totalQuestions: reportData.total,
      correctCount: reportData.correct,
      wrongCount: reportData.wrong,
      unansweredCount: reportData.unanswered,
      questionBankName: reportData.questionBankName,
      // 传递所有题目的答题状态
      answerStatus: questionNumbers.map(item => ({
        questionNumber: item.number,
        status: item.status,
        originalIndex: item.originalIndex,
        questionId: item.questionId // 包含题目ID
      }))
    };
    
    console.log('跳转参数:', jumpParams);
    
    // 跳转到新的题目解析页面
    wx.navigateTo({
      url: `/index/pages/questionAnalysis/questionAnalysis?reportData=${encodeURIComponent(JSON.stringify(jumpParams))}`,
      success: () => {
        console.log('跳转到题目解析页面成功');
      },
      fail: (err) => {
        console.error('跳转到题目解析页面失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        });
      }
    });
  },

    /**
   * 自动保存答题记录（无需用户手动操作）
   */
  autoSaveAnswerRecord() {
    console.log('开始自动保存答题记录...');
    
    // 检查用户登录状态
    if (!this.checkUserLogin()) {
      console.log('用户未登录，自动保存失败');
      return;
    }
    
    // 构建符合接口要求的答题记录数据
    const answerRecord = this.buildAnswerRecordData();
    
    if (!answerRecord.userId) {
      console.log('未获取到用户ID，自动保存失败');
      return;
    }
    
    console.log('自动保存答题记录数据:', answerRecord);
    
    // 静默保存，不显示加载提示
    this.directHttpRequest('/wjq/answerrecord', answerRecord, true);
  },



  /**
   * 手动保存答题记录到后端
   */
  saveAnswerRecord() {
    try {
      // 检查用户登录状态
      if (!this.checkUserLogin()) {
        return;
      }
      
      // 构建符合接口要求的答题记录数据
      const answerRecord = this.buildAnswerRecordData();
      
      if (!answerRecord.userId) {
        wx.showToast({
          title: '请先登录',
          icon: 'none',
          duration: 2000
        });
        return;
      }
      
      // 显示加载提示
      wx.showLoading({
        title: '保存中...',
        mask: true
      });
      
      // 调用保存接口
      console.log('开始调用保存接口...');
      
      // 直接使用wx.request作为主要方法
      this.directHttpRequest('/wjq/answerrecord', answerRecord, false);
      
    } catch (e) {
      wx.hideLoading();
      console.error('构建答题记录数据失败:', e);
      wx.showToast({
        title: '数据构建失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  /**
   * 显示错题解析
   */
  showWrongAnalysis() {
    const { reportData, questionNumbers, questionBankId } = this.data;
    
    console.log('显示错题解析 - 当前数据:', {
      reportData,
      questionNumbers,
      questionBankId
    });
    
    // 筛选出错题
    const wrongQuestions = questionNumbers.filter(item => item.status === 'wrong');
    
    console.log('筛选出的错题:', wrongQuestions);
    
    if (wrongQuestions.length === 0) {
      wx.showToast({
        title: '没有错题！',
        icon: 'success'
      });
      return;
    }
    
    // 准备跳转参数
    const jumpParams = {
      mode: 'wrong', // 错题模式
      from: 'wrongQuestions', // 来源：错题
      questionBankId: questionBankId || reportData.questionBankId,
      totalQuestions: reportData.total,
      wrongCount: reportData.wrong,
      questionBankName: reportData.questionBankName,
      // 只传递错题的状态
      wrongQuestions: wrongQuestions.map(item => ({
        questionNumber: item.number,
        status: item.status,
        originalIndex: item.originalIndex,
        questionId: item.questionId // 包含题目ID
      }))
    };
    
    console.log('错题解析跳转参数:', jumpParams);
    
    // 跳转到新的题目解析页面
    wx.navigateTo({
      url: `/index/pages/questionAnalysis/questionAnalysis?reportData=${encodeURIComponent(JSON.stringify(jumpParams))}`,
      success: () => {
        console.log('跳转到错题解析页面成功');
      },
      fail: (err) => {
        console.error('跳转到错题解析页面失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        });
      }
    });
  },



  /**
   * 返回上一页
   */
  goBack() {
    wx.navigateBack();
  },

  /**
   * 页面卸载时清理计时器
   */
  onUnload() {
    if (this.data.timerInterval) {
      clearInterval(this.data.timerInterval);
      console.log('页面卸载，清理计时器');
    }
  },

  /**
   * 页面隐藏时暂停计时器
   */
  onHide() {
    if (this.data.isTimerRunning) {
      console.log('页面隐藏，暂停计时器');
      // 可以选择暂停计时器或继续计时
    }
  },

  /**
   * 页面显示时恢复计时器
   */
  onShow() {
    if (this.data.isTimerRunning && !this.data.timerInterval) {
      console.log('页面显示，恢复计时器');
      this.startTimer();
    }
  },

  /**
   * 分享答题报告
   */
  onShareAppMessage() {
    const { reportData } = this.data;
    return {
      title: `我在${reportData.questionBankName}中答对了${reportData.correct}/${reportData.total}题，正确率${reportData.correctRate}%！`,
      path: '/index/pages/answerReport/answerReport',
      imageUrl: '/images/share-answer-report.png' // 可以添加分享图片
    };
  },

  /**
   * 分享到朋友圈
   */
  onShareTimeline() {
    const { reportData } = this.data;
    return {
      title: `答题报告：${reportData.correct}/${reportData.total}题，正确率${reportData.correctRate}%`,
      imageUrl: '/images/share-answer-report.png'
    };
  }
});